use std::{cmp::Ordering, collections::HashMap, io};
use rand::Rng;
fn main() {
    // fn first_word(s: &String) -> &str {
    //     let bytes = s.as_bytes();
    
    //     for (i, &item) in bytes.iter().enumerate() {
    //         if item == b' ' {
    //             return &s[0..i];
    //         }
    //     }
    
    //     &s[..]
    // }
    
    // let mut s1 = String::from("foo");
    // let s2 = "bar";
    // s1.push('l');
    // println!("s2 is {s2}");

    // let mut scores = HashMap::new();
    // scores.insert(String::from("Blue"), 10);
    // scores.insert(String::from("Yellow"), 50);
    // let score = scores.get("blue").copied().unwrap_or(0);
    // scores.entry(String::from("blue")).or_insert(100);

    // pub struct NewArticle {
    //     pub headline: String,
    //     pub location: String
    // }

    // pub trait Summary {
    //     fn summarize(&self) -> String;
    // }

    // impl Summary for NewArticle {
    //     fn summarize(&self) -> String {
    //         todo!()
    //     }
    // }

    // pub fn notify<T: Summary>(item: &T) {
    //     println!("Breaking news!{}", item.summarize())
    // }


    // struct ImportantExcerpt<'a> {
    //     part: &'a str,
    // }

    // impl<'a> ImportantExcerpt<'a> {
    //     fn level(&self) -> i32 {
    //         3
    //     }
    // }

    
        



    // println!("Guess the number!");

    // let secret_number = rand::thread_rng().gen_range(1..=100);
    
    // loop {
    //     println!("Please input your guess.");
    //     let mut guess = String::new();
    //     io::stdin()
    //         .read_line(&mut guess)
    //         .expect("Failed to read line");
    //     let guess:u32= match guess.trim().parse() {
    //         Ok(num) => num,
    //         Err(_) => continue
    //     };

    //     println!("You guessed: {guess}");

    //     match guess.cmp(&secret_number) {
    //         Ordering::Less => println!("Too small!"),
    //         Ordering::Greater => println!("Too big!"),
    //         Ordering::Equal => {
    //             println!("You win!");
    //             break;
    //         }
    //     }
    // }

    // struct User{
    //     active: bool,
    //     username: String,
    //     email: String,
    //     sign_in_count: u64
    // }

    // let mut user1 = User {
    //     active: true,
    //     username: String::from("abin"),
    //     email: String::from("abin@qq.com"),
    //     sign_in_count: 1,
    // };
    // user1.active = false;
    

    // fn build_user(email: String, username: String) -> User{
    //     User{
    //         active: true,
    //         username,
    //         email,
    //         sign_in_count: 1
    //     }
    // }

    // let mut user2 = User{
    //     email: String::from("good@qq.com"),
    //     ..user1
    // };

    // user2.username = String::from("good");

    // struct Color(i32, i32, i32);
    // struct Point(i32, i32, i32);

    // let black = Color(0,0,0);
    // let origin = Point(0,0,0);
    
    // struct Rectangle{
    //     width: u32,
    //     height: u32
    // }

    // impl Rectangle {
    //     fn area(&self) -> u32 {
    //         self.width * self.height
    //     }
    //     fn suqare(size: u32) -> Self {
    //         Self{
    //             width: size,
    //             height: size
    //         }
    //     }
    // }

    // let rect1 = Rectangle {
    //     width: 30,
    //     height: 50
    // };
    // rect1.area();

    // enum IpAddrKind {
    //     V4(u8,u8,u8,u8),
    //     V6(String)
    // }

    // fn route(ip_kind_:IpAddrKind) {

    // }
    // route(IpAddrKind::V4(127,0,0,1));
    // route(IpAddrKind::V6(String::from("::1")));

    // enum Message {
    //     Quit, // 没有关联任何数据
    //     Move {x : i32, y: i32},  // 类似结构体包含命名字段
    //     Write(String), // 包含一个String
    //     ChangeColor(i32,i32,i32) // 包含三个i32
    // }

    // impl Message {
    //     fn call(&self) {
            
    //     }
    // }

    // let x:i8 = 5;
    // let y:Option<i8> = Some(5);
    // // let sum = x + y;

    // enum UsState {
    //     Alabama,
    //     Alaska
    // }
    // enum Coin {
    //     Penny,
    //     Nickel,
    //     Dime,
    //     Quarter(UsState)
    // }
    // fn value_in_cents(coin: Coin) -> u8 {
    //     match coin {
    //         Coin::Penny => 1,
    //         Coin::Nickel => 5,
    //         Coin::Dime => 10,
    //         Coin::Quarter(state) => {
    //             println!("State quarter from {:?}!", state);
    //             25
    //         }
    //     }
    // }

    // fn plus_one(x: Option<i32>) -> Option<i32> {
    //     match x {
    //         None => None,
    //         Some(i) => Some(i+1)
    //     }
    // }
    // let five = Some(5);
    // let size = plus_one(five);
    // let none = plus_one(None);

    // let dice_roll = 9;
    // fn add() {}
    // fn remove() {}
    // fn move_player(num: u8) {}
    // match dice_roll {
    //     3 => add(),
    //     7 => remove(),
    //     other => move_player(other)
    // }

    // let config_max = Some(3u8);
    // match config_max {
    //     Some(max) => println!("The maximum is configured to be {}", max),
    //     _ => ()
    // }

    // let mut count = 0;
    // if let Coin::Quarter(state) = coin {
    //     println!("State quarter from {:?}!", state);
    // } else {
    //     count += 1;
    // }


}
